// 基础axios配置 - 可切换mock数据与实际API请求
import axios from 'axios'
import appConfig from '@/config/appConfig'
import { useMock } from '@/config/appConfig'

// 导入mock数据相关模块
import { getCategoriesMock, getCoursesMock, addCourseMock, updateCourseMock, deleteCourseMock, getCourseByIdMock, getCourseSubitemsMock, getCourseCommentsMock, addCourseCommentMock, addCourseSubitemMock } from '@/mock/mockData'
import mockAPI from '@/mock/mockData'

// 创建axios实例
const api = axios.create({
  baseURL: appConfig.apiBaseUrl,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 创建demo API实例
const demoApi = axios.create({
  baseURL: `${appConfig.apiBaseUrl}/demo`,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 创建course API实例
const courseApi = axios.create({
  baseURL: `${appConfig.apiBaseUrl}/course`,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 创建user API实例
const userApi = axios.create({
  baseURL: `${appConfig.apiBaseUrl}/user`,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 模拟异步请求的工具函数 - 确保返回标准格式的响应
const mockRequest = (data, delay = appConfig.mockDelay) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      // 总是返回成功格式的响应，保持一致
      resolve({
        errno: 0,
        message: 'success',
        data: data
      })
    }, delay)
  })
}

// 请求拦截器 - 为courseApi添加Authorization头部
courseApi.interceptors.request.use(
  config => {
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  error => {
    console.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器 - 确保正确处理课程API的响应格式
courseApi.interceptors.response.use(
  response => {
    // 保持完整的响应对象格式
    return response
  },
  error => {
    console.error('响应错误:', error)
    return Promise.reject(error)
  }
)

// 请求拦截器
api.interceptors.request.use(
  config => {
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  error => {
    console.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    return response.data
  },
  error => {
    console.error('响应错误:', error)
    return Promise.reject(new Error('网络请求失败，请检查网络连接或稍后重试'))
  }
)

// 表名索引映射 - 与后端保持一致
const TABLE_NAMES = {
  COURSES: 6,
  CATEGORIES: 5 // categories表的正确索引值
}

// 用户API的请求拦截器
userApi.interceptors.request.use(
  config => {
    const token = localStorage.getItem('token')
    if (token) {
      config.headers.Authorization = `Bearer ${token}`
    }
    return config
  },
  error => {
    console.error('用户API请求错误:', error)
    return Promise.reject(error)
  }
)

// 用户API的响应拦截器
userApi.interceptors.response.use(
  response => {
    // 直接返回响应数据
    return response.data
  },
  error => {
    console.error('用户API响应错误:', error)
    if (error.response) {
      console.error('错误状态码:', error.response.status)
      console.error('错误响应数据:', error.response.data)
      return Promise.reject(error)
    }
    return Promise.reject(new Error('网络请求失败，请检查网络连接'))
  }
)

// 用户相关API - 完全调用远程后端接口
export const userAPI = {
  register: (userInfo) => {
    try {
      // 根据当前useMock状态决定是否使用mock数据
      if (useMock) {
        // 创建一个模拟的成功响应
        const mockResponse = {
          errno: 0,
          data: {
            id: Math.floor(Math.random() * 10000),
            username: userInfo.username,
            email: userInfo.email || '',
            avatar: '',
            createTime: new Date().toISOString()
          },
          message: '注册成功'
        }
        return mockRequest(mockResponse)
      } else {
        // 使用已配置的userApi实例，确保拦截器和其他配置都能正确应用
        return userApi.post('/reg', userInfo)
          .then(response => {
            console.log('注册API响应:', response)
            // 正确处理响应，检查errno字段
            if (response && response.errno === 0) {
              return response
            } else {
              // 即使HTTP状态码是200，如果errno不为0也视为失败
              throw new Error(response?.message || '注册失败，请稍后重试')
            }
          })
      }
    } catch (error) {
      console.error('注册API错误:', error)
      throw error
    }
  },
  login: (credentials) => {
    try {
      // 根据当前useMock状态决定是否使用mock数据
      if (useMock) {
        // 创建一个模拟的成功响应
        const mockResponse = {
          errno: 0,
          data: {
            id: Math.floor(Math.random() * 10000) + 100,
            username: credentials.username,
            token: 'mock-token-' + Date.now(),
            avatar: '',
            email: credentials.username + '@example.com'
          },
          message: '登录成功'
        }
        return mockRequest(mockResponse)
      } else {
        // 使用已配置的userApi实例，确保拦截器和其他配置都能正确应用
        return userApi.post('/login', credentials)
          .then(response => {
            console.log('登录API响应:', response)
            return response
          })
      }
    } catch (error) {
      console.error('登录API错误:', error)
      throw error
    }
  }
}

// 演示相关API
export const demoAPI = {
  login: (credentials) => {
    try {
      // 根据当前useMock状态决定是否使用mock数据
      if (useMock) {
        // 创建一个模拟的成功响应
        const mockResponse = {
          errno: 0,
          data: {
            token: 'demo-token-' + Date.now(),
            userInfo: {
              id: 1,
              username: credentials.username,
              avatar: ''
            }
          },
          message: '登录成功'
        }
        return mockRequest(mockResponse)
      } else {
        return demoApi.post('/user/login', credentials)
      }
    } catch (error) {
      console.error('登录失败:', error)
      throw new Error('登录失败，请稍后重试')
    }
  }
}

// 课程相关API - 完全连接远程服务器
export const courseAPI = {
  // 获取所有课程 - 根据配置决定使用mock数据或实际API请求
getAllCourses: () => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      const courses = getCoursesMock()
      return mockRequest(courses).then(response => {
        // 确保返回的是数据数组，而不是包含errno的响应对象
        return response.data || []
      })
    } else {
      // 调用后端API获取课程列表
      return demoApi.get('/getallitems', {
        params: {
          typeIndex: TABLE_NAMES.COURSES
        }
      }).then(response => {
        console.log('获取课程列表成功:', response)
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0 && Array.isArray(response.data.data)) {
            return response.data.data
          } else if (Array.isArray(response.data)) {
            // 兼容旧格式的响应
            return response.data
          }
        }
        return []
      }).catch(error => {
        console.error('获取课程列表失败:', error)
        return Promise.reject(new Error('获取课程列表失败，请检查网络连接'))
      })
    }
  },
  
  // 获取单个课程 - 根据配置决定使用mock数据或实际API请求
  getCourseById: (id) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      // 确保id是数字类型
      const courseId = parseInt(id)
      console.log('查找课程ID:', courseId)
      
      // 使用getCourseByIdMock获取课程详情，确保与任务项和评价数据匹配
      const course = getCourseByIdMock(courseId)
      
      if (course) {
        console.log('找到课程:', course)
        // 直接传递课程对象，mockRequest会包装成标准响应格式
        return mockRequest(course)
      }
      
      console.log('未找到课程，ID:', courseId)
      // 返回标准格式的响应，告知前端课程不存在
      return mockRequest(null)
    } else {
      // 调用后端专门的课程详情API
      return courseApi.get(`/getCourseById/${id}`).then(response => {
        console.log('获取单个课程成功:', response)
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0) {
            return response.data.data || null
          } else if (response.data.errno !== undefined) {
            // 如果有错误状态码，返回错误信息
            throw new Error(response.data.message || '获取课程失败')
          } else if (response.data.id) {
            // 兼容旧格式的响应
            return response.data
          }
        }
        return null
      }).catch(error => {
        console.error('获取单个课程失败:', error)
        return Promise.reject(new Error('获取课程失败，请检查网络连接'))
      })
    }
  },
  
  // 添加课程 - 根据配置决定使用mock数据或实际API请求
  addCourse: (courseData) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      const result = addCourseMock(courseData)
      return mockRequest(result)
    } else {
      // 准备要发送到后端的数据
      const dataToSend = {
        ...courseData
      }
      
      // 调用专门的课程添加API
      return courseApi.post('/addCourse', dataToSend).then(response => {
        console.log('添加课程API响应:', response)
        
        // 正确处理响应，直接返回后端响应的data部分
        if (response && response.data) {
          return response.data
        }
        
        // 处理非标准格式响应
        console.warn('添加课程API返回非标准格式响应:', response)
        return { errno: 1, message: '响应格式错误，添加课程失败' }
      }).catch(error => {
        console.error('添加课程请求失败:', error)
        return Promise.reject(new Error('添加课程失败，请检查网络连接'))
      })
    }
  },
  
  // 更新课程 - 根据配置决定使用mock数据或实际API请求
  updateCourse: (courseData) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      // 模拟更新课程成功
      return mockRequest({
        errno: 0,
        message: 'success',
        data: courseData
      })
    } else {
      // 准备要发送到后端的数据
      const dataToSend = {
        ...courseData,
        typeIndex: TABLE_NAMES.COURSES
      }
      
      // 调用后端API更新课程
      return demoApi.post('/updateitem', dataToSend).then(response => {
        console.log('更新课程成功:', response)
        
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0) {
            return response.data
          } else if (response.data.errno !== undefined) {
            // 如果有错误状态码，返回错误信息
            throw new Error(response.data.message || '更新课程失败')
          }
        }
        return response.data || {}
      }).catch(error => {
        console.error('更新课程失败:', error)
        return Promise.reject(new Error('更新课程失败，请检查网络连接'))
      })
    }
  },
  
  // 删除课程 - 根据配置决定使用mock数据或实际API请求
  deleteCourse: (id) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      // 模拟删除课程成功
      return mockRequest({
        errno: 0,
        message: 'success',
        data: { success: true, deletedId: id }
      })
    } else {
      // 调用专门的课程删除API
      return courseApi.post('/deleteCourse', { id: id }).then(response => {
        console.log('删除课程API响应:', response)
        
        // 正确处理响应
        if (response && response.data) {
          return response.data
        }
        
        return { errno: 1, message: '删除课程失败' }
      }).catch(error => {
        console.error('删除课程请求失败:', error)
        return Promise.reject(new Error('删除课程失败，请检查网络连接'))
      })
    }
  }
}

// 课程类别相关API
export const categoryAPI = {
  // 获取所有类别 - 根据配置决定使用mock数据或实际API请求
  getAllCategories: (categoryType = '课程') => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      const categories = getCategoriesMock()
      return mockRequest(categories).then(response => {
        // 确保返回的是数据数组，而不是包含errno的响应对象
        return response.data || []
      })
    } else {
      // 使用统一配置的baseURL
      return courseApi.get('/getCategories', {
        params: {
          categoryType: categoryType
        }
      }).then(response => {
        console.log('获取类别列表成功:', response)
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0 && Array.isArray(response.data.data)) {
            return response.data.data
          } else if (Array.isArray(response.data)) {
            // 兼容旧格式的响应
            return response.data
          }
        }
        return []
      }).catch(error => {
        console.error('获取类别列表失败:', error)
        return Promise.reject(new Error('获取类别列表失败，请检查网络连接'))
      })
    }
  },
  
  // 添加类别 - 根据配置决定使用mock数据或实际API请求
  addCategory: (categoryData) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      try {
        // 创建符合mockAPI期望格式的数据
        const mockData = {
          title: categoryData.title || categoryData.categoryName,
          categoryType: '课程'
        }
        
        // 调用mockAPI的addCategory方法来实际更新mock数据
        return mockAPI.addCategory(mockData)
      } catch (error) {
        console.error('添加类别mock数据失败:', error)
        return mockRequest({
          errno: 1,
          message: '添加类别失败'
        })
      }
    } else {
      // 准备要发送到后端的数据，后端course.js中的addCategory接口期望接收title字段
      const dataToSend = {
        ...categoryData,
        categoryType: '课程' // 设置类别类型为课程
      }
      
      // 使用统一配置的courseApi实例
      return courseApi.post('/addCategory', dataToSend)
        .then(response => {
          console.log('添加类别API响应:', response)
          
          // 正确处理响应，直接返回后端响应的data部分
          if (response && response.data) {
            return response.data
          }
          
          // 处理非标准格式响应
          console.warn('添加类别API返回非标准格式响应:', response)
          return { errno: 1, message: '响应格式错误，添加类别失败' }
        }).catch(error => {
          console.error('添加类别请求失败:', error)
          return Promise.reject(new Error('添加类别失败，请检查网络连接'))
        })
    }
  },
  
  // 获取单个类别 - 调用远程后端API
  getCategoryById: (id) => {
    // 调用后端API，传递typeIndex参数指定为类别表
    return demoApi.get('/getsingle', {
      params: {
        id: id,
        typeIndex: TABLE_NAMES.CATEGORIES
      }
    }).then(response => {
      console.log('获取单个类别成功:', response)
      // 处理标准格式的响应：{ errno: 0, data: result }
      if (response.data && typeof response.data === 'object') {
        if (response.data.errno === 0) {
          return response.data.data || null
        } else if (response.data.errno !== undefined) {
          // 如果有错误状态码，返回错误信息
          throw new Error(response.data.message || '获取类别失败')
        } else if (response.data.id) {
          // 兼容旧格式的响应
          return response.data
        }
      }
      return null
    }).catch(error => {
      console.error('获取单个类别失败:', error)
      return Promise.reject(new Error('获取类别失败，请检查网络连接'))
    })
  },
  
  // 删除类别 - 根据配置决定使用mock数据或实际API请求
  deleteCategory: (id) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      // 模拟删除类别成功
      return mockRequest({
        errno: 0,
        message: 'success',
        data: { success: true }
      })
    } else {
      // 调用后端API删除类别
      return demoApi.post('/deleteitem', {
        delid: id,
        typeIndex: TABLE_NAMES.CATEGORIES
      }).then(response => {
        console.log('删除类别API响应:', response)
        
        // 正确处理响应，直接返回后端响应的data部分
        if (response && response.data) {
          return response.data
        }
        
        // 处理非标准格式响应
        console.warn('删除类别API返回非标准格式响应:', response)
        return { errno: 1, message: '响应格式错误，删除失败' }
      }).catch(error => {
        console.error('删除类别请求失败:', error)
        return Promise.reject(new Error('删除类别失败，请检查网络连接'))
      })
    }
  }
}

// 其他API完善实现
export const subitemAPI = {
  // 获取课程任务项 - 根据配置决定使用mock数据或实际API请求
  getCourseSubitems: (courseId) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      const subitems = getCourseSubitemsMock(courseId)
      return mockRequest(subitems)
    } else {
      // 调用后端专门的课程任务项API
      return courseApi.get(`/getCourseSubitems/${courseId}`).then(response => {
        console.log('获取课程任务项成功:', response)
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0 && Array.isArray(response.data.data)) {
            return response.data.data
          } else if (Array.isArray(response.data)) {
            return response.data
          }
        }
        return []
      }).catch(error => {
        console.error('获取课程任务项失败:', error)
        return Promise.reject(new Error('获取课程任务项失败，请检查网络连接'))
      })
    }
  },
  
  // 添加课程任务项 - 根据配置决定使用mock数据或实际API请求
  addCourseSubitem: (subitemData) => {
    try {
      // 根据当前useMock状态决定是否使用mock数据
      if (useMock) {
        // 实际更新mock数据
        const result = addCourseSubitemMock(subitemData.courseId, subitemData)
        
        // 确保返回的数据包含所有前端需要的字段
        const mockSubitem = {
          ...result,
          courseId: subitemData.courseId,
          // 映射字段以匹配CourseDetailView.vue所需的数据结构
          body: subitemData.description || '', // description -> body
          addedTime: new Date().toISOString(), // 添加时间戳
          authorName: subitemData.username || subitemData.authorName || '23002944' // 添加作者名
        }
        
        return mockRequest({
          errno: 0,
          message: 'success',
          data: mockSubitem
        })
      } else {
        // 准备发送到后端的数据，确保字段名与后端要求一致
        const dataToSend = {
          ...subitemData,
          parentid: subitemData.courseId, // 后端需要parentid而不是courseId
          parentType: '课程', // 设置父项类型为课程
          userid: subitemData.userId // 确保使用正确的字段名userid
        }
        
        // 删除不需要的字段
        delete dataToSend.courseId;
        delete dataToSend.userId;
        delete dataToSend.authorName;
        delete dataToSend.addedTime;
        
        // 调用后端API添加任务项
        return courseApi.post('/addSubitem', dataToSend).then(response => {
          console.log('添加课程任务项API响应:', response)
          
          // 处理标准格式的响应
          if (response.data && typeof response.data === 'object') {
            if (response.data.errno === 0 && response.data.data) {
              // 添加成功，返回后端数据
              return {
                errno: 0,
                message: 'success',
                data: response.data.data
              }
            }
          }
          
          // 处理非标准格式响应
          console.warn('添加课程任务项API返回非标准格式响应:', response)
          return {
            errno: 1,
            message: '添加任务项失败',
            data: null
          }
        }).catch(error => {
          console.error('添加课程任务项请求失败:', error)
          throw error
        })
      }
    } catch (error) {
      console.error('添加任务项失败:', error)
      return mockRequest({
        errno: 1,
        message: '添加任务项失败'
      })
    }
  }
}

export const commentAPI = {
  // 获取课程评价 - 根据配置决定使用mock数据或实际API请求
  getCourseComments: (courseId) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      const comments = getCourseCommentsMock(courseId)
      return mockRequest({
        errno: 0,
        message: 'success',
        data: comments
      })
    } else {
      return courseApi.get(`/getComments/${courseId}`).then(response => {
        console.log('获取课程评价成功:', response)
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0 && Array.isArray(response.data.data)) {
            return response.data.data
          } else if (Array.isArray(response.data)) {
            // 兼容旧格式的响应
            return response.data
          }
        }
        return []
      }).catch(error => {
        console.error('获取课程评价失败:', error)
        return Promise.reject(new Error('获取课程评价失败，请检查网络连接'))
      })
    }
  },
  
  // 添加课程评价 - 根据配置决定使用mock数据或实际API请求
  addCourseComment: (commentData) => {
    // 根据当前useMock状态决定是否使用mock数据
    if (useMock) {
      const result = addCourseCommentMock(commentData)
      // 返回标准格式的响应对象
      return mockRequest({
        errno: 0,
        message: 'success',
        data: result
      })
    } else {
      return courseApi.post('/addComment', commentData).then(response => {
        console.log('添加课程评价成功:', response)
        // 处理标准格式的响应：{ errno: 0, data: result }
        if (response.data && typeof response.data === 'object') {
          if (response.data.errno === 0) {
            return response.data
          } else if (response.data.errno !== undefined) {
            // 如果有错误状态码，返回错误信息
            throw new Error(response.data.message || '添加评价失败')
          }
        }
        return response.data || {} 
      }).catch(error => {
        console.error('添加课程评价失败:', error)
        throw error
      })
    }
  }
}

export const uploadAPI = {
  uploadImage: (formData) => Promise.resolve({ errno: 0, message: 'success', data: { url: 'http://via.placeholder.com/300x200' } })
}

// 导出必要的常量和API实例
export { TABLE_NAMES, courseApi }
export default api